import Vue from 'vue'
import * as api from '@/api/api'
import { isURL } from '@/utils/validate'
import moment from 'moment'
import { ACCESS_TOKEN } from '@/store/mutation-types'
import { getDictItemsFromCache, getSubordinateList } from '../api/api'
import store from '../store'
import { USER_INFO } from '../store/mutation-types'

export function timeFix() {
  const time = new Date()
  const hour = time.getHours()
  return hour < 9 ? '早上好' : hour <= 11 ? '上午好' : hour <= 13 ? '中午好' : hour < 20 ? '下午好' : '晚上好'
}
export function bytesToMB(bytes) {
  return (bytes / 1024 / 1024).toFixed(2)
}

export function welcome() {
  const arr = ['休息一会儿吧', '准备吃什么呢?', '要不要打一把 DOTA', '我猜你可能累了']
  let index = Math.floor(Math.random() * arr.length)
  return arr[index]
}
export function convertToYYYYMM(input) {
  const dateStr = input.split(' ')[0] // 提取 "2025/03/19"

  const [year, month] = dateStr.split('/')

  return `${year}-${month.padStart(2, '0')}` // 补零确保两位月份
}
/**
 * 将任意格式日期字符串转换为时间戳（毫秒）
 * @param {string} dateStr - 日期字符串（支持格式：YYYY/MM/DD、YYYY-MM-DD、YYYYMMDD等）
 * @returns {number} 时间戳（毫秒）
 */
export function toTimestamp1(dateStr) {
  // 统一替换为标准格式（处理斜杠/短横线/无分隔符）
  const normalized = dateStr.replace(/[/-]/g, '').replace(/^(\d{4})(\d{2})(\d{2})/, '$1/$2/$3')

  // 手动解析日期组件
  const [year, month, day, hours, minutes, seconds] =
    normalized.match(/(\d{4})(\d{2})(\d{2})?(\d{2})?(\d{2})?(\d{2})?/) || [].slice(1, 7).map(Number)

  // 处理时间部分（默认00:00:00）
  const timePart = hours !== undefined ? (hours * 3600 + minutes * 60 + seconds) * 1000 : 0

  // 构造UTC时间（避免时区偏移）
  const utcDate = Date.UTC(
    year,
    month - 1, // 月份从0开始
    day || 1, // 处理无日期的情况
    hours || 0,
    minutes || 0,
    seconds || 0
  )

  return utcDate + timePart
}
export function toTimestamp(yearMonth) {
  const [year, month] = yearMonth.split('-').map(Number)

  return Date.UTC(year, month - 1, 1) // 月份从 0 开始，日期补 1
}

/**
 * 触发 window.resize
 */
export function triggerWindowResizeEvent() {
  let event = document.createEvent('HTMLEvents')
  event.initEvent('resize', true, true)
  event.eventType = 'message'
  window.dispatchEvent(event)
}

/**
 * 过滤对象中为空的属性
 * @param obj
 * @returns {*}
 */
export function filterObj(obj) {
  if (!(typeof obj == 'object')) {
    return
  }

  for (let key in obj) {
    if (obj.hasOwnProperty(key) && (obj[key] == null || obj[key] == undefined || obj[key] === '')) {
      delete obj[key]
    }
  }
  return obj
}

export function commitTrim(values) {
  for (var i in values) {
    if (typeof values[i] == 'string') values[i] = values[i].trim()
  }
  return values[i]
}

export function under18(idNo) {
  if (!/^\d{17}[\dX]$/i.test(idNo)) throw new Error('身份证号格式错误')

  // 出生年月日字符串：2022-05-07
  const birthStr = `${idNo.slice(6, 10)}-${idNo.slice(10, 12)}-${idNo.slice(12, 14)}`
  const birth = new Date(birthStr).getTime()
  if (Number.isNaN(birth)) throw new Error('出生日期非法')

  // 18 年对应的毫秒数（按平均 365.25 天）
  const EIGHTEEN_YEARS = 18 * 365.25 * 24 * 3600 * 1000
  return Date.now() - birth < EIGHTEEN_YEARS
}

/**
 * 时间格式化
 * @param value
 * @param fmt
 * @returns {*}
 */
export function formatDate(value, fmt) {
  let regPos = /^\d+(\.\d+)?$/
  if (regPos.test(value)) {
    //如果是数字
    let getDate = new Date(value)
    let o = {
      'M+': getDate.getMonth() + 1,
      'd+': getDate.getDate(),
      'h+': getDate.getHours(),
      'm+': getDate.getMinutes(),
      's+': getDate.getSeconds(),
      'q+': Math.floor((getDate.getMonth() + 3) / 3),
      S: getDate.getMilliseconds(),
    }
    if (/(y+)/.test(fmt)) {
      fmt = fmt.replace(RegExp.$1, (getDate.getFullYear() + '').substr(4 - RegExp.$1.length))
    }
    for (let k in o) {
      if (new RegExp('(' + k + ')').test(fmt)) {
        fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length))
      }
    }
    return fmt
  } else {
    value = value.trim()
    return value.substr(0, fmt.length)
  }
}

//获取一个月前的日期 （30天）
Date.prototype.getMonthBefore = function () {
  return new Date(new Date(new Date(new Date().toLocaleDateString()).getTime()) - 1000 * 60 * 60 * 24 * 30)
}

//当天的开始时间  00:00:00
Date.prototype.getCurrentData = function () {
  return new Date().toLocaleDateString()
}

//当天的当前时间
Date.prototype.getEndData = function () {
  return moment().format('YYYY/MM/DD HH:mm:ss')
}

// 生成首页路由
export function generateIndexRouter(data) {
  let indexRouter = [
    {
      path: '/',
      name: 'dashboard',
      component: (resolve) => require(['@/components/layouts/TabLayout'], resolve),
      meta: { title: '首页' },
      redirect: (to) => {
        const userInfo = Vue.ls.get(USER_INFO)
        if (userInfo.role === 'love_and_care') {
          return '/humanisticConcern/oneMap'
        } else if (userInfo.role === 'key_care') {
          return '/careFamily/largeScreen/index'
        } else {
          return '/dashboard/analysis'
        }
      },
      children: [...generateChildRouters(data)],
    },
    {
      path: '*',
      redirect: '/404',
      hidden: true,
    },
  ]
  return indexRouter
}

// 生成嵌套路由（子路由）

function generateChildRouters(data) {
  const routers = []
  for (let item of data) {
    // console.log(item.component, 'component')
    // // * 按钮权限没有component 跳过循环 否则不能生成路由 报错跳转首页
    // if (item.component == undefined) {
    //   break
    // }
    let component = ''
    if (item.component) {
      if (item.component.indexOf('layouts') >= 0) {
        component = 'components/' + item.component
      } else {
        component = 'views/' + item.component
      }
    }

    // eslint-disable-next-line
    let URL = (item.meta.url || '').replace(/{{([^}}]+)?}}/g, (s1, s2) => eval(s2)) // URL支持{{ window.xxx }}占位符变·量
    if (isURL(URL)) {
      item.meta.url = URL
    }

    let componentPath = (resolve) => require(['@/' + component + '.vue'], resolve)

    let menu = {
      path: item.path || '/xx',
      name: item.name,
      redirect: item.redirect,
      component: componentPath,
      //component: resolve => require(['@/' + component+'.vue'], resolve),
      hidden: item.hidden,
      //component:()=> import(`@/views/${item.component}.vue`),
      meta: {
        title: item.meta.title,
        icon: item.meta.icon,
        url: item.meta.url,
        permissionList: item.meta.permissionList,
        keepAlive: item.meta.keepAlive,
        /*update_begin author:wuxianquan date:20190908 for:赋值 */
        internalOrExternal: item.meta.internalOrExternal,
        /*update_end author:wuxianquan date:20190908 for:赋值 */
        componentName: item.meta.componentName,
      },
    }
    if (item.alwaysShow) {
      menu.alwaysShow = true
      menu.redirect = menu.path
    }
    if (item.children && item.children.length > 0) {
      menu.children = [...generateChildRouters(item.children)]
    }
    //--update-begin----author:scott---date:20190320------for:根据后台菜单配置，判断是否路由菜单字段，动态选择是否生成路由（为了支持参数URL菜单）------
    //判断是否生成路由
    if (item.route && item.route === '0') {
      //console.log(' 不生成路由 item.route：  '+item.route);
      //console.log(' 不生成路由 item.path：  '+item.path);
    } else {
      routers.push(menu)
    }
    //--update-end----author:scott---date:20190320------for:根据后台菜单配置，判断是否路由菜单字段，动态选择是否生成路由（为了支持参数URL菜单）------
  }
  return routers
}

/**
 * 深度克隆对象、数组
 * @param obj 被克隆的对象
 * @return 克隆后的对象
 */
export function cloneObject(obj) {
  return JSON.parse(JSON.stringify(obj))
}

/**
 * 随机生成数字
 *
 * 示例：生成长度为 12 的随机数：randomNumber(12)
 * 示例：生成 3~23 之间的随机数：randomNumber(3, 23)
 *
 * @param1 最小值 | 长度
 * @param2 最大值
 * @return int 生成后的数字
 */
export function randomNumber() {
  // 生成 最小值 到 最大值 区间的随机数
  const random = (min, max) => {
    return Math.floor(Math.random() * (max - min + 1) + min)
  }
  if (arguments.length === 1) {
    let [length] = arguments
    // 生成指定长度的随机数字，首位一定不是 0
    let nums = [...Array(length).keys()].map((i) => (i > 0 ? random(0, 9) : random(1, 9)))
    return parseInt(nums.join(''))
  } else if (arguments.length >= 2) {
    let [min, max] = arguments
    return random(min, max)
  } else {
    return Number.NaN
  }
}

/**
 * 随机生成字符串
 * @param length 字符串的长度
 * @param chats 可选字符串区间（只会生成传入的字符串中的字符）
 * @return string 生成的字符串
 */
export function randomString(length, chats) {
  if (!length) length = 1
  if (!chats) chats = '0123456789qwertyuioplkjhgfdsazxcvbnm'
  let str = ''
  for (let i = 0; i < length; i++) {
    let num = randomNumber(0, chats.length - 1)
    str += chats[num]
  }
  return str
}

/**
 * 随机生成uuid
 * @return string 生成的uuid
 */
export function randomUUID() {
  let chats = '0123456789abcdef'
  return randomString(32, chats)
}

/**
 * 下划线转驼峰
 * @param string
 * @returns {*}
 */
export function underLine2CamelCase(string) {
  return string.replace(/_([a-z])/g, function (all, letter) {
    return letter.toUpperCase()
  })
}

/**
 * 判断是否显示办理按钮
 * @param bpmStatus
 * @returns {*}
 */
export function showDealBtn(bpmStatus) {
  if (bpmStatus != '1' && bpmStatus != '3' && bpmStatus != '4') {
    return true
  }
  return false
}

/**
 * 增强CSS，可以在页面上输出全局css
 * @param css 要增强的css
 * @param id style标签的id，可以用来清除旧样式
 */
export function cssExpand(css, id) {
  let style = document.createElement('style')
  style.type = 'text/css'
  style.innerHTML = `@charset "UTF-8"; ${css}`
  // 清除旧样式
  if (id) {
    let $style = document.getElementById(id)
    if ($style != null) $style.outerHTML = ''
    style.id = id
  }
  // 应用新样式
  document.head.appendChild(style)
}

/** 用于js增强事件，运行JS代码，可以传参 */
// options 所需参数：
//    参数名         类型            说明
//    vm             VueComponent    vue实例
//    event          Object          event对象
//    jsCode         String          待执行的js代码
//    errorMessage   String          执行出错后的提示（控制台）
export function jsExpand(options = {}) {
  // 绑定到window上的keyName
  let windowKeyName = 'J_CLICK_EVENT_OPTIONS'
  if (typeof window[windowKeyName] != 'object') {
    window[windowKeyName] = {}
  }

  // 随机生成JS增强的执行id，防止冲突
  let id = randomString(16, 'qwertyuioplkjhgfdsazxcvbnm'.toUpperCase())
  // 封装按钮点击事件
  let code = `
    (function (o_${id}) {
      try {
        (function (globalEvent, vm) {
          ${options.jsCode}
        })(o_${id}.event, o_${id}.vm)
      } catch (e) {
        o_${id}.error(e)
      }
      o_${id}.done()
    })(window['${windowKeyName}']['EVENT_${id}'])
  `
  // 创建script标签
  const script = document.createElement('script')
  // 将需要传递的参数挂载到window对象上
  window[windowKeyName]['EVENT_' + id] = {
    vm: options.vm,
    event: options.event,
    // 当执行完成时，无论如何都会调用的回调事件
    done() {
      // 执行完后删除新增的 script 标签不会撤销执行结果（已产生的结果不会被撤销）
      script.outerHTML = ''
      delete window[windowKeyName]['EVENT_' + id]
    },
    // 当js运行出错的时候调用的事件
    error(e) {
      console.group(`${options.errorMessage || '用户自定义JS增强代码运行出错'}（${new Date()}）`)
      console.error(e)
      console.groupEnd()
    },
  }
  // 将事件挂载到document中
  script.innerHTML = code
  document.body.appendChild(script)
}

/**
 * 重复值验证工具方法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateDuplicateValue('sys_fill_rule', 'rule_code', value, this.model.id, callback) }
 *
 * @param tableName 被验证的表名
 * @param fieldName 被验证的字段名
 * @param fieldVal 被验证的值
 * @param dataId 数据ID，可空
 * @param callback
 */
export function validateDuplicateValue(tableName, fieldName, fieldVal, dataId, callback) {
  if (fieldVal) {
    let params = { tableName, fieldName, fieldVal, dataId }
    api
      .duplicateCheck(params)
      .then((res) => {
        res['success'] ? callback() : callback(res['message'])
      })
      .catch((err) => {
        callback(err.message || err)
      })
  } else {
    callback()
  }
}

/**
 * 根据编码校验规则code，校验传入的值是否合法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateCheckRule('common', value, callback) }
 *
 * @param ruleCode 编码校验规则 code
 * @param value 被验证的值
 * @param callback
 */
export function validateCheckRule(ruleCode, value, callback) {
  if (ruleCode && value) {
    value = encodeURIComponent(value)
    api
      .checkRuleByCode({ ruleCode, value })
      .then((res) => {
        res['success'] ? callback() : callback(res['message'])
      })
      .catch((err) => {
        callback(err.message || err)
      })
  } else {
    callback()
  }
}

/**
 * 如果值不存在就 push 进数组，反之不处理
 * @param array 要操作的数据
 * @param value 要添加的值
 * @param key 可空，如果比较的是对象，可能存在地址不一样但值实际上是一样的情况，可以传此字段判断对象中唯一的字段，例如 id。不传则直接比较实际值
 * @returns {boolean} 成功 push 返回 true，不处理返回 false
 */
export function pushIfNotExist(array, value, key) {
  for (let item of array) {
    if (key && item[key] === value[key]) {
      return false
    } else if (item === value) {
      return false
    }
  }
  array.push(value)
  return true
}

/**
 * 可用于判断是否成功
 * @type {symbol}
 */
export const succeedSymbol = Symbol()
/**
 * 可用于判断是否失败
 * @type {symbol}
 */
export const failedSymbol = Symbol()

/**
 * 使 promise 无论如何都会 resolve，除非传入的参数不是一个Promise对象或返回Promise对象的方法
 * 一般用在 Promise.all 中
 *
 * @param promise 可传Promise对象或返回Promise对象的方法
 * @returns {Promise<any>}
 */
export function alwaysResolve(promise) {
  return new Promise((resolve, reject) => {
    let p = promise
    if (typeof promise === 'function') {
      p = promise()
    }
    if (p instanceof Promise) {
      p.then((data) => {
        resolve({ type: succeedSymbol, data })
      }).catch((error) => {
        resolve({ type: failedSymbol, error })
      })
    } else {
      reject('alwaysResolve: 传入的参数不是一个Promise对象或返回Promise对象的方法')
    }
  })
}

/**
 * 简单实现防抖方法
 *
 * 防抖(debounce)函数在第一次触发给定的函数时，不立即执行函数，而是给出一个期限值(delay)，比如100ms。
 * 如果100ms内再次执行函数，就重新开始计时，直到计时结束后再真正执行函数。
 * 这样做的好处是如果短时间内大量触发同一事件，只会执行一次函数。
 *
 * @param fn 要防抖的函数
 * @param delay 防抖的毫秒数
 * @returns {Function}
 */
export function simpleDebounce(fn, delay = 100) {
  let timer = null
  return function () {
    let args = arguments
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(() => {
      fn.apply(this, args)
    }, delay)
  }
}

/**
 * 不用正则的方式替换所有值
 * @param text 被替换的字符串
 * @param checker  替换前的内容
 * @param replacer 替换后的内容
 * @returns {String} 替换后的字符串
 */
export function replaceAll(text, checker, replacer) {
  let lastText = text
  text = text.replace(checker, replacer)
  if (lastText !== text) {
    return replaceAll(text, checker, replacer)
  }
  return text
}

/**
 * 获取事件冒泡路径，兼容 IE11，Edge，Chrome，Firefox，Safari
 * 目前使用的地方：JEditableTable Span模式
 */
export function getEventPath(event) {
  let target = event.target
  let path = (event.composedPath && event.composedPath()) || event.path

  if (path != null) {
    return path.indexOf(window) < 0 ? path.concat(window) : path
  }

  if (target === window) {
    return [window]
  }

  let getParents = (node, memo) => {
    memo = memo || []
    const parentNode = node.parentNode

    if (!parentNode) {
      return memo
    } else {
      return getParents(parentNode, memo.concat(parentNode))
    }
  }
  return [target].concat(getParents(target), window)
}

/**
 * 根据组件名获取父级
 * @param vm
 * @param name
 * @returns {Vue | null|null|Vue}
 */
export function getVmParentByName(vm, name) {
  let parent = vm.$parent
  if (parent && parent.$options) {
    if (parent.$options.name === name) {
      return parent
    } else {
      let res = getVmParentByName(parent, name)
      if (res) {
        return res
      }
    }
  }
  return null
}

/**
 * 使一个值永远不会为（null | undefined）
 *
 * @param value 要处理的值
 * @param def 默认值，如果value为（null | undefined）则返回的默认值，可不传，默认为''
 */
export function neverNull(value, def) {
  return value == null ? neverNull(def, '') : value
}

/**
 * 根据元素值移除数组中的一个元素
 * @param array 数组
 * @param prod 属性名
 * @param value 属性值
 * @returns {string}
 */
export function removeArrayElement(array, prod, value) {
  let index = -1
  for (let i = 0; i < array.length; i++) {
    if (array[i][prod] == value) {
      index = i
      break
    }
  }
  if (index >= 0) {
    array.splice(index, 1)
  }
}

/**
 * 获取积木报表打印地址
 * @param url
 * @param id
 * @param open 是否自动打开
 * @returns {*}
 */
export function getReportPrintUrl(url, id, open) {
  // URL支持{{ window.xxx }}占位符变量
  url = url.replace(/{{([^}]+)?}}/g, (s1, s2) => eval(s2))
  if (url.includes('?')) {
    url += '&'
  } else {
    url += '?'
  }
  url += `id=${id}`
  url += `&token=${Vue.ls.get(ACCESS_TOKEN)}`
  if (open) {
    window.open(url)
  }
  return url
}

/**
 * JS实现AOP切面
 *
 * @param obj 包含函数的对象
 * @param funcName 要切面的函数名
 * @param callback 执行方法前的回调，用于切面，callback的返回值就是funcName最终的返回值
 */
export function aspectAroundFunction(obj, funcName, callback) {
  if (typeof callback !== 'function' || !obj) {
    console.warn('【aspectAroundFunction】obj或callback格式不正确')
    return
  }
  // 保存原来的函数
  let func = obj[funcName]
  if (typeof func !== 'function') {
    console.warn('【aspectAroundFunction】' + funcName + '不是一个方法')
    return
  }
  // 赋值新方法
  // 实现当外部调用 funcName 时，首先调用我定义的新方法
  // 然后调用传入的callback方法，以决定是否执行 funcName，以及更改参数、返回值
  obj[funcName] = function (...args) {
    return callback({
      args,
      // 只有执行 proceed 才会真正执行给定的 funcName 方法
      proceed() {
        try {
          return func.apply(obj, args)
        } catch (e) {
          console.error(e)
        }
      },
    })
  }
}

/* 时间格式化 */
export function formatters(timestamp, type) {
  var date = new Date(timestamp) //时间戳为10位需*1000，时间戳为13位的话不需乘1000
  var YY = date.getFullYear()
  var MM = date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1
  var DD = date.getDate() < 10 ? '0' + date.getDate() : date.getDate()
  var HH = date.getHours() < 10 ? '0' + date.getHours() : date.getHours()
  var mm = date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()
  var ss = date.getSeconds()
  let time
  time = YY + '-' + MM + '-' + DD + ' ' + HH + ':' + mm + ':00'
  if (type == 'YY') {
    time = YY
  }
  if (type == 'MM') {
    time = MM
  }
  if (type == 'DD') {
    time = DD
  }
  if (type == 'HH') {
    time = HH
  }
  if (type == 'mm') {
    time = mm
  }
  if (type == 'ss') {
    time = ss
  }
  if (type == 'YY-MM') {
    time = YY + '-' + MM
  }
  if (type == 'YY-MM-DD') {
    time = YY + '-' + MM + '-' + DD
  }
  if (type == 'YY/MM/DD') {
    time = YY + '/' + MM + '/' + DD
  }
  if (type == 'YY-MM-DD HH') {
    time = YY + '-' + MM + '-' + DD + ' ' + HH
  }
  if (type == 'YY-MM-DD HH:mm') {
    time = YY + '-' + MM + '-' + DD + ' ' + HH + ':' + mm
  }
  if (type == 'YY/MM/DD HH:mm') {
    time = YY + '/' + MM + '/' + DD + ' ' + HH + ':' + mm
  }
  if (type == 'YY-MM-DD HH:mm:ss') {
    time = YY + '-' + MM + '-' + DD + ' ' + HH + ':' + mm + ':' + ss
  }
  if (type == 'timestamp') {
    time = date.getTime()
  }
  if (type == 'wordMinute') {
    time = YY + '年' + MM + '月' + DD + '日' + HH + '时' + mm + '分'
  }
  if (type == 'wordTime') {
    time = YY + '年' + MM + '月' + DD + '日' + HH + '时'
  }
  if (type == 'wordDay') {
    time = YY + '年' + MM + '月' + DD + '日'
  }
  return time
}

/* 时间格式化 中文*/
export function formattersWord(dateStr) {
  let yymmdd = formatters(dateStr, 'YY-MM-DD')

  var dict = {
    0: '零',
    1: '一',
    2: '二',
    3: '三',
    4: '四',
    5: '五',
    6: '六',
    7: '七',
    8: '八',
    9: '九',
    10: '十',
    11: '十一',
    12: '十二',
    13: '十三',
    14: '十四',
    15: '十五',
    16: '十六',
    17: '十七',
    18: '十八',
    19: '十九',
    20: '二十',
    21: '二十一',
    22: '二十二',
    23: '二十三',
    24: '二十四',
    25: '二十五',
    26: '二十六',
    27: '二十七',
    28: '二十八',
    29: '二十九',
    30: '三十',
    31: '三十一',
  }
  var date = yymmdd.split('-'),
    yy = date[0],
    mm = +date[1],
    dd = +date[2]

  var yearStr = dict[yy[0]] + dict[yy[1]] + dict[yy[2]] + dict[yy[3]] + '年',
    monthStr = dict['' + Number(mm)] + '月',
    dayStr = dict[dd] + '日'

  return yearStr + monthStr + dayStr
}

/**
 *
 */

export function getPrefixImg() {
  let item = getDictItemsFromCache('static_server').find((item) => item.title === 'static_server_url')
  if (item) {
    return item.value
  }
}

// 处理行业树
export function processIndustryTree(list) {
  return list.map((item) => {
    let newItem = {
      value: item.id,
      label: item.informationName,
      children: item.children && item.children.length ? item.children : null,
    }
    // 如果新的 有孩子
    if (newItem.children && newItem.children.length) {
      newItem.children = processIndustryTree(newItem.children)
    }
    return newItem
  })
}

/**
 *
 * @param {图片预览} imgList
 * @returns
 */
export function previewImage(imgList = []) {
  const prefixImg = getPrefixImg()

  imgList = imgList.filter((item) => !!Boolean(item))
  if (!imgList.length) {
    return
  }
  let images = imgList.map((item) => {
    return prefixImg + item
  })
  // 拼接前缀
  const $viewer = this.$viewerApi({
    images,
  })
}

/**
 * 标准地址选择
 * @param {*} value
 * @param {*} type
 * @returns
 */
export async function handleSelectChange(value, type) {
  value = value ? value.trim() : value
  // 清空相关联的值
  if (!value) {
    this.frontDataZ = this.villageList.slice(0, 100)
    // 根据 type 清空下拉框的值
    switch (type) {
      //街路巷
      case 1: {
        this.queryParam.jzfDzbm = undefined
        this.queryParam.dyfDzbm = undefined
        this.queryParam.lcfDzbm = undefined
        this.queryParam.fjfDzbm = undefined
        break
      }
      case 2: {
        this.queryParam.dyfDzbm = undefined
        this.queryParam.lcfDzbm = undefined
        this.queryParam.fjfDzbm = undefined
        break
      }
      case 3: {
        this.queryParam.lcfDzbm = undefined
        this.queryParam.fjfDzbm = undefined
        break
      }
      case 4: {
        this.queryParam.fjfDzbm = undefined
        break
      }
      default: {
        break
      }
    }
  }
  // 获取下一级 选项数据
  if (!value) return
  try {
    let res = await getSubordinateList({
      fDzbm: value,
      type,
    })
    if (res.code == 200) {
      const { result = [] } = res
      switch (type) {
        // 街路巷
        case 1: {
          this.buildingList = result
          this.unitList = []
          this.floorList = []
          this.roomList = []
          this.queryParam.jzfDzbm = undefined
          this.queryParam.dyfDzbm = undefined
          this.queryParam.lcfDzbm = undefined
          this.queryParam.fjfDzbm = undefined
          break
        }
        // 建筑物
        case 2: {
          this.unitList = result
          this.floorList = []
          this.roomList = []
          this.queryParam.dyfDzbm = undefined
          this.queryParam.lcfDzbm = undefined
          this.queryParam.fjfDzbm = undefined
          break
        }
        // 单元
        case 3: {
          this.floorList = result
          this.roomList = []
          this.queryParam.lcfDzbm = undefined
          this.queryParam.fjfDzbm = undefined
          break
        }
        // 楼层
        case 4: {
          this.roomList = result
          this.$set(this.queryParam, 'fjfDzbm', undefined)
          break
        }
        default: {
          break
        }
      }
    }
  } catch (error) {}
}

/**
 * 如果找到目标值，则直接返回
 * @param {} tree
 * @param {*} target
 */
export function findNode(tree, target) {}

/**
 * 获取 url 参数
 * @returns
 */
export function getUrlParamsAsObject() {
  const search = window.location.search.substr(1)
  const params = {}
  const pairs = search.split('&').filter((item) => Boolean(item))
  for (let i = 0; i < pairs.length; i++) {
    const pair = pairs[i].split('=')
    const key = decodeURIComponent(pair[0])
    const value = decodeURIComponent(pair[1])
    if (params[key] === undefined) {
      params[key] = value
    } else {
      if (!Array.isArray(params[key])) {
        params[key] = [params[key], value]
      } else {
        params[key].push(value)
      }
    }
  }
  return params
}

export function clearCurrentUrlParams() {
  const url = new URL(window.location.href)
  const pathname = url.pathname
  const origin = url.origin
  history.replaceState({}, '', origin + pathname)
}

// 给 body 添加属性
export function addHtmlStyleProps(width = 297) {
  let html = document.querySelector('html')

  html.style['min-width'] = `${width}mm !important`
  html.style['width'] = `${width}mm`
  html.style['height'] = 'auto !important'
  html.style['margin'] = '0 auto'
  html.style['overflow'] = 'visible !important'
  html.style['background'] = '#F0F2F5'

  let body = document.body.setAttribute(
    'style',
    `width: ${width}mm;height:auto !important;overflow:visible !important;margin: 0 auto;`
  )
  let app = document
    .getElementById('app')
    .setAttribute('style', `width: ${width}mm;height:auto !important;overflow:visible !important;`)
}

// 删除 body 上添加的属性
export function removeHtmlStyleProps() {
  // 删除 html 上面除了 font-size 属性的其他值
  let html = document.querySelector('html')
  let style = html.getAttribute('style')
  let styles = style.split(';')
  const retainProps = ['font-size']
  retainProps.forEach((prop) => {
    styles = styles.filter((stylePart) => stylePart.trim().startsWith(prop))
  })
  html.setAttribute('style', styles.join(';'))

  document.body.removeAttribute('style')
  document.getElementById('app').removeAttribute('style')
}

export function getParentsById(list, id) {
  for (let i in list) {
    if (list[i].id === id) {
      //查询到就返回该数组对象 自己本身不算在内
      return []
    }

    if (list[i].children) {
      let node = getParentsById(list[i].children, id)
      if (node !== undefined) {
        //查询到把父节点连起来
        return node.concat(list[i])
      }
    }
  }
}

export const collectTypeMap = {
  1: '民警',
  2: '网格员',
  3: '辅警',
}

export const getStartTimeOfDay = () => {
  let currentDate = new Date()
  currentDate.setHours(0)
  currentDate.setMinutes(0)
  currentDate.setSeconds(0)
  currentDate.setMilliseconds(0)
  return currentDate.getTime()
}

export const getEndTimeOfDay = () => {
  let currentDate = new Date()
  currentDate.setHours(23)
  currentDate.setMinutes(59)
  currentDate.setSeconds(59)
  currentDate.setMilliseconds(999)
  return currentDate.getTime()
}

export function sortPolygonPointsClockwise(points) {
  // 计算多边形的重心（这里简单地使用算术平均法来计算，对于经纬度可能有一定误差，但可用于大致判断）
  function calculateCentroid(polyPoints) {
    let xSum = 0
    let ySum = 0
    for (let i = 0; i < polyPoints.length; i++) {
      xSum += polyPoints[i][0]
      ySum += polyPoints[i][1]
    }
    return [xSum / polyPoints.length, ySum / polyPoints.length]
  }

  // 使用向量叉积来比较角度，以确定点相对于重心的顺序
  function crossProduct(a, b, c) {
    return (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1])
  }

  const centroid = calculateCentroid(points)
  return points.sort((a, b) => {
    const angleA = Math.atan2(a[1] - centroid[1], a[0] - centroid[0])
    const angleB = Math.atan2(b[1] - centroid[1], b[0] - centroid[0])
    return angleA - angleB
  })
}

//范围算法
export function ConvexHull(lines) {
  //排序去重
  for (let i = 0; i < lines.length; i++) {
    for (let j = 0; j < lines.length - i - 1; j++) {
      if (lines[j].x > lines[j + 1].x) {
        let tamp = lines[j]
        lines[j] = lines[j + 1]
        lines[j + 1] = tamp
      }
      if (lines[j].x == lines[j + 1].x && lines[j].y == lines[j + 1].y) {
        lines.splice(j + 1, 1)
        j--
      }
    }
  }
  let result = []
  let index = 1
  result.push(lines[0])
  while (true) {
    let point = findNext(lines, result[index - 2], result[index - 1])
    if (point == null) break
    result.push(point)
    if (point.x == lines[0].x && point.y == lines[0].y) {
      break
    }
    if (index > lines.length + 2) {
      break
    }
    index++
  }
  return result
}

function findNext(lines, start, node) {
  for (let i = 0; i < lines.length; i++) {
    if (start != null && start.x == lines[i].x && start.y == lines[i].y) {
      continue
    }
    if (node != null && node.x == lines[i].x && node.y == lines[i].y) {
      continue
    }
    let search = true
    let target = -9999
    for (let j = 0; j < lines.length; j++) {
      if (i == j) continue
      if (node != null && node.x == lines[j].x && node.y == lines[j].y) {
        continue
      }
      let left =
        sub(node.x, lines[j].x) * sub(lines[i].y, lines[j].y) - sub(node.y, lines[j].y) * sub(lines[i].x, lines[j].x) >
        0
          ? true
          : false
      if (target == -9999) {
        target = left
      }
      if (left != target) {
        search = false
        break
      }
    }
    if (search == true) {
      return lines[i]
    }
  }
}

function sub(a, b) {
  var c, d, e
  try {
    c = a.toString().split('.')[1].length
  } catch (f) {
    c = 0
  }
  try {
    d = b.toString().split('.')[1].length
  } catch (f) {
    d = 0
  }
  return (e = Math.pow(10, Math.max(c, d))), (mul(a, e) - mul(b, e)) / e
}

function mul(a, b) {
  var c = 0,
    d = a.toString(),
    e = b.toString()
  try {
    c += d.split('.')[1].length
  } catch (f) {}
  try {
    c += e.split('.')[1].length
  } catch (f) {}
  return (Number(d.replace('.', '')) * Number(e.replace('.', ''))) / Math.pow(10, c)
}

export function getZeroTimeStampOfDay(date = new Date()) {
  // 创建传入日期（如果没传则为当前日期）对应的Date对象
  const targetDate = new Date(date)
  // 设置小时、分钟、秒和毫秒都为0，得到当天00:00:00的Date对象
  targetDate.setHours(0)
  targetDate.setMinutes(0)
  targetDate.setSeconds(0)
  targetDate.setMilliseconds(0)
  // 获取对应的时间戳（以毫秒为单位）
  return targetDate.getTime()
}

// 获取某一天23:59:59秒的时间戳的函数
export function getEndOfDayTimeStamp(date = new Date()) {
  // 创建传入日期（如果没传则为当前日期）对应的Date对象
  const targetDate = new Date(date)
  // 设置小时为23，分钟为59，秒为59，毫秒为999，得到当天23:59:59的Date对象
  targetDate.setHours(23)
  targetDate.setMinutes(59)
  targetDate.setSeconds(59)
  targetDate.setMilliseconds(999)
  // 获取对应的时间戳（以毫秒为单位）
  return targetDate.getTime()
}

// 获取本月开始时间（本月1号00:00:00）对应的Date对象
export function getStartDateOfThisMonth() {
  const currentDate = new Date()
  const year = currentDate.getFullYear()
  const month = currentDate.getMonth()
  const startDate = new Date(year, month, 1)
  startDate.setHours(0)
  startDate.setMinutes(0)
  startDate.setSeconds(0)
  startDate.setMilliseconds(0)
  return startDate.getTime()
}

// 获取本月结束时间（本月最后一天23:59:59）对应的Date对象
export function getEndDateOfThisMonth() {
  const currentDate = new Date()
  const year = currentDate.getFullYear()
  const month = currentDate.getMonth()
  const nextMonth = month + 1
  const yearOfNextMonth = nextMonth > 11 ? year + 1 : year
  const monthOfNextMonth = nextMonth > 11 ? 0 : nextMonth
  const endDate = new Date(yearOfNextMonth, monthOfNextMonth, 0)
  endDate.setHours(23)
  endDate.setMinutes(59)
  endDate.setSeconds(59)
  endDate.setMilliseconds(999)
  return endDate.getTime()
}

// 引入moment.js库
// 或者在浏览器环境中通过script标签引入后使用window.moment

// 获取本周开始时间（周一00:00:00）对应的Date对象
export function getStartDateOfThisWeekWithMoment() {
  const currentMoment = moment()
  const startMoment = currentMoment.startOf('week')
  return startMoment.toDate().valueOf()
}

// 获取本周结束时间（周日23:59:59）对应的Date对象
export function getEndDateOfThisWeekWithMoment() {
  const currentMoment = moment()
  const endMoment = currentMoment.endOf('week')
  return endMoment.toDate().valueOf()
}

//获取组件 DOM 信息
export const getComponentDom = (component, props) => {
  let mountNode = document.createElement('div')

  return new Promise((resolve, reject) => {
    new Vue({
      el: mountNode,
      render: (h) =>
        h(component, {
          ...props,
        }),
      mounted() {
        resolve(this.$el)
      },
    }).$mount()
  })
}

export const problemTypeEnum = {
  1: '功能异常',
  2: '产品改进',
}

export const softwareTypeEnum = {
  1: '民警',
  2: '网格员',
  3: '辅警',
  4: '群众',
}
